{
  const getData = () => new Promise((r) => setTimeout(() => r('data'), 1000));
  async function test() {
    const data = await getData();
    console.log('data: ', data);
    const data2 = await getData();
    console.log('data2: ', data2);
    return 'success';
  }
  // 这样的一个函数 应该再1秒后打印data 再过一秒打印data2 最后打印success
  test().then((res) => console.log(res));
}

{
  // 手动调用generator函数
  const getData = () => new Promise((r) => setTimeout(() => r('data'), 1000));
  function* testG() {
    const data = yield getData();
    console.log('data: ', data);
    const data1 = yield getData();
    console.log('data1: ', data1);
    return 'success';
  }

  var gen = testG();

  var dataPromise = gen.next();

  dataPromise.value.then((value1) => {
    // data1的value被拿到了 继续调用next并且传递给data
    var data2Promise = gen.next(value1);

    // console.log('data: ', data);
    // 此时就会打印出data

    data2Promise.value.then((value2) => {
      // data2的value拿到了 继续调用next并且传递value2
      gen.next(value2);

      // console.log('data2: ', data2);
      // 此时就会打印出data2
    });
  });
}

{
  /**
   * async的执行原理
   * 其实就是自动执行generator函数
   * 暂时不考虑genertor的编译步骤（更复杂）
   */

  const getData = () => new Promise((r) => setTimeout(() => r('data'), 1000));

  // async函数会被编译成generator函数 (babel会编译成更本质的形态，这里我们直接用generator)
  function* testG() {
    // await被编译成了yield
    const data = yield getData();
    console.log('data: ', data);
    const data2 = yield getData();
    console.log('data2: ', data2);
    return data + '123';
  }

  // asyncToGenerator接受一个generator函数，返回一个promise
  function asyncToGenerator(generatorFunc) {
    // 返回的是一个新的函数
    return function () {
      // 先调用generator函数 生成迭代器（其实就是testG函数）
      // 对应 var gen = testG()
      const gen = generatorFunc.apply(this, arguments);
      // 返回一个promise 因为外部是用.then的方式 或者await的方式去使用这个函数的返回值的
      // var test = asyncToGenerator(testG)
      // test().then(res => console.log(res))
      return new Promise((resolve, reject) => {
        // 内部定义一个step函数 用来一步一步的跨过yield的阻碍
        // key 有 next 和 throw 两种取值，分别对应了gen 的 next 和 throw 方法
        // arg参数则是用来把promise resolve出来的值交给下一个yield
        function step(key, arg) {
          let generatorResult;
          // 这个方法需要包裹在try catch中
          // 如果报错了 就把promise给reject掉 外部通过.catch可以获取到错误
          try {
            generatorResult = gen[key](arg);
          } catch (error) {
            return reject(error);
          }

          // gen.next() 得到的结果是一个 { value, done } 的结构
          const { value, done } = generatorResult;

          if (done) {
            // 如果已经完成了 就直接resolve这个promise
            // 这个done是在最后一次调用next后才会为true
            // 以本文的例子来说 此时的结果是 { done: true, value: 'success' }
            // 这个value也就是generator函数最后的返回值
            return resolve(value);
          } else {
            // 除了最后结束的时候外，每次调用gen.next()
            // 其实是返回 { value: Promise, done: false } 的结构，
            // 这里要注意的是Promise.resolve可以接受一个promise为参数
            // 并且这个promise参数被resolve的时候，这个then才会被调用
            return Promise.resolve(
              // 这个value对应的是yield后面的promise
              value
            ).then(
              // value这个promise被resove的时候，就会执行next
              // 并且只要done不是true的时候 就会递归的往下解开promise
              // 对应gen.next().value.then(value => {
              //    gen.next(value).value.then(value2 => {
              //       gen.next()
              //
              //      // 此时done为true了 整个promise被resolve了
              //      // 最外部的test().then(res => console.log(res))的then就开始执行了
              //    })
              // })
              function onResolve(val) {
                step('next', val);
              },
              // 如果promise被reject了 就再次进入step函数
              // 不同的是，这次的try catch中调用的是gen.throw(err)
              // 那么自然就被catch到 然后把promise给reject掉啦
              function onReject(err) {
                step('throw', err);
              }
            );
          }
        }
        step('next');
      });
    };
  }

  function asyncToGenerator(generatorFunc) {
    return function () {
      const gen = generatorFunc.apply(this, arguments);
      return new Promise((resolve, reject) => {
        function step(key, arg) {
          let generatorResult;
          try {
            generatorResult = gen[key](arg);
          } catch (error) {
            return reject(error);
          }
          const { value, done } = generatorResult;
          if (done) {
            return resolve(value);
          } else {
            return Promise.resolve(value).then(
              (val) => step('next', val),
              (err) => step('throw', err)
            );
          }
        }
        step('next');
      });
    };
  }

  const testGAsync = asyncToGenerator(testG);
  testGAsync().then((result) => {
    console.log(result);
  });
}
